import {
  x as C,
  r as ae,
  i as u,
  o as i,
  a as z,
  m as e,
  l,
  k as y,
  F as J,
  j as X,
  b as f,
  t as V,
  e as s,
  u as j,
  O as K,
  P as R,
  Q as ee,
  B as g,
} from "./index-abba05ce.js";

const Ye = { class: "admin-lists" },
  Ze = { class: "border-none mt-2" },
  Je = { class: "d-flex flex-wrap items-center" },
  Xe = { class: "filters" },
  Ke = { class: "border-none mt-3" },
  Qe = { class: "d-flex justify-content-end mt-4" };

// 状态选项 - 根据spj_feedback表结构
const STATUS_OPTIONS = [
  { label: "全部状态", value: "" },
  { label: "待处理", value: 0 },
  { label: "已采纳", value: 1 },
  { label: "已忽略", value: 2 },
];

// 场景选项 - 根据spj_feedback表结构
const SCENE_OPTIONS = [
  { label: "全部场景", value: "" },
  { label: "功能异常", value: 0 },
  { label: "产品建议", value: 1 },
  { label: "违规举报", value: 2 },
];

// 格式化状态文本
const formatStatusText = (status) => {
  switch (status) {
    case 0: return "待处理";
    case 1: return "已采纳";
    case 2: return "已忽略";
    default: return "-";
  }
};

// 格式化场景文本
const formatSceneText = (scene) => {
  switch (scene) {
    case 0: return "功能异常";
    case 1: return "产品建议";
    case 2: return "违规举报";
    default: return "-";
  }
};

// 格式化时间戳
const formatTimestamp = (value) => {
  if (!value) return "-";
  const timestamp = String(value).length === 10 ? Number(value) * 1e3 : Number(value);
  if (!timestamp || Number.isNaN(timestamp)) return "-";
  const date = new Date(timestamp);
  if (Number.isNaN(date.getTime())) return "-";
  const pad = (num) => `${num}`.padStart(2, "0");
  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
};

// 全局错误处理，捕获所有未处理的错误
window.onerror = function(message, source, lineno, colno, error) {
    console.error('全局错误捕获:', { message, source, lineno, colno, error });
    // 确保错误信息被完整记录，特别是关于index-c715a378.js的错误
    if (source && source.includes('index-c715a378.js')) {
        console.error('检测到与index-c715a378.js相关的错误:', { message, source, lineno, colno });
        // 尝试查找并打印调用栈
        if (error && error.stack) {
            console.error('错误栈:', error.stack);
        }
    }
    // 返回true表示错误已处理，不会继续抛出
    return true;
};

// 修复footer组件中的copyright数组错误
// 检查并创建全局对象路径
if (typeof window !== 'undefined') {
    // 尝试在全局对象中找到L对象并修复其配置
    try {
        // 寻找可能的全局状态对象L
        let LObject;
        // 检查常见的全局变量
        for (const key in window) {
            if (typeof window[key] === 'object' && window[key] !== null && 
                'state' in window[key] && 'app' in window[key].state && 
                'config' in window[key].state.app) {
                LObject = window[key];
                break;
            }
        }
        
        // 如果找到L对象，确保其config.copyright是有效的数组
        if (LObject && LObject.state && LObject.state.app) {
            const appState = LObject.state.app;
            if (!appState.config) {
                appState.config = {};
            }
            // 确保copyright是数组，至少包含5个元素以避免[0]和[4]索引错误
            if (!Array.isArray(appState.config.copyright) || appState.config.copyright.length < 5) {
                appState.config.copyright = [0, '', '', '', ''];
                console.log('已修复全局配置的copyright数组');
            }
        } else {
            console.log('未找到L对象，但将继续执行');
        }
    } catch (e) {
        console.error('尝试修复全局配置时出错:', e);
    }
}

const et = {
  __name: "index",
  setup() {
    // 筛选条件 - 根据spj_feedback表结构
    const filters = ae({ id: "", scene: "", status: "", user: "" });
    // 表格数据 - 初始化为空数组，避免undefined
    const tableData = C([]);
    // 加载状态
    const loading = C(!1);
    // 分页信息 - 确保所有属性都有默认值
    const pagination = ae({ page: 1, pageSize: 20, total: 0 });
    
    // 添加一个安全的数据获取方法，确保返回的始终是有效的数组
    const getSafeArray = (data) => {
        if (!data) return [];
        if (Array.isArray(data)) return data;
        return [];
    };

    const buildParams = () => {
      const params = {
        page: pagination.page,
        page_size: pagination.pageSize,
      };
      if (filters.id) params.id = filters.id;
      if (filters.user) params.user = filters.user;
      if (filters.scene !== "") params.scene = filters.scene;
      if (filters.status !== "") params.status = filters.status;
      return params;
    };

    const fetchList = async () => {
      tableData.value = []; // 每次调用前先清空并设置为有效数组
      loading.value = !0;
      try {
        // 确保buildParams返回有效对象
        const params = typeof buildParams === 'function' ? buildParams() : {};
        // 确保K.feedback和list方法存在
        if (!K || !K.feedback || typeof K.feedback.list !== 'function') {
            console.error("Feedback API not available");
            R.msgError("API服务不可用");
            return;
        }
        const res = await K.feedback.list(params);
        // 严格检查响应结构
        if (!res || typeof res !== 'object') {
            console.error("Invalid response structure");
            R.msgError("获取列表失败：响应格式错误");
            return;
        }
        if (res.error) {
            R.msgError(res.msg || "获取列表失败");
            return;
        }
        const data = res.data || {};
        // 使用安全的方法确保rawData始终是有效的数组
        const rawData = getSafeArray(data.data);
        // 确保map处理每个项目时不会出错，过滤掉无效数据
        tableData.value = rawData
            .filter(item => item && typeof item === 'object') // 只处理有效的对象
            .map(item => {
                // 处理images字段，支持数组、字符串格式的JSON数组、空值等
                let images = [];
                try {
                    if (Array.isArray(item.images)) {
                        // 已经是数组
                        images = item.images;
                    } else if (typeof item.images === 'string') {
                        // 尝试解析字符串格式的JSON数组，如'[]'或'["url1", "url2"]'
                        if (item.images.trim() === '[]') {
                            // 空数组字符串
                            images = [];
                        } else {
                            // 尝试JSON解析
                            const parsed = JSON.parse(item.images);
                            if (Array.isArray(parsed)) {
                                images = parsed;
                            }
                        }
                    }
                    // 确保最终是数组，且每个元素是字符串
                    images = images.filter(img => typeof img === 'string');
                } catch (error) {
                    console.error("Error parsing images:", error, "item.images:", item.images);
                    images = [];
                }
                return {
                    id: item.id || '',
                    scene: typeof item.scene === 'number' ? item.scene : 0,
                    user_id: item.user_id || '',
                    content: item.content || '',
                    contact: item.contact || '',
                    create_time: item.create_time || '',
                    update_time: item.update_time || '',
                    status: typeof item.status === 'number' ? item.status : 0,
                    images: images, // 确保总是返回有效的字符串数组
                    user: item.user || {}, 
                    ip: item.ip || '',
                    ua: item.ua || ''
                };
            });
        // 安全更新分页信息
        pagination.total = typeof data.total === 'number' ? data.total : 0;
        pagination.page = typeof data.page === 'number' ? data.page : pagination.page;
        pagination.pageSize = typeof data.pageSize === 'number' ? data.pageSize : pagination.pageSize;
      } catch (err) {
        console.error("fetch list error:", err);
        R.msgError("获取列表失败");
        tableData.value = []; // 确保总是设置为空数组
      } finally {
        loading.value = !1;
        
        // 执行最终数据验证，确保tableData中的每一项都没有可能导致数组索引错误的问题
        try {
            // 再次确保tableData是有效的数组
            if (!Array.isArray(tableData.value)) {
                console.warn('数据验证失败: tableData不是数组');
                tableData.value = [];
                return;
            }
            
            // 验证并修复每一条记录
            tableData.value = tableData.value.map((item, index) => {
                // 确保每一项都是有效对象
                if (!item || typeof item !== 'object') {
                    console.warn(`第${index}条数据不是有效对象，已忽略`);
                    return null;
                }
                
                // 确保images字段始终是有效的数组
                if (item.images === undefined || item.images === null || !Array.isArray(item.images)) {
                    item.images = [];
                }
                
                // 打印第一条数据的结构，帮助调试
                if (index === 0) {
                    console.log('第一条数据的images结构:', { 
                        type: typeof item.images,
                        isArray: Array.isArray(item.images),
                        length: item.images ? item.images.length : 'undefined',
                        // 不打印完整内容，避免过大输出
                        sample: item.images.slice(0, 1)
                    });
                }
                
                return item;
            }).filter(Boolean); // 过滤掉null项
            
            console.log(`数据验证完成: 共有${tableData.value.length}条有效记录`);
        } catch (error) {
            console.error('数据验证过程发生错误:', error);
            tableData.value = []; // 出错时确保tableData为空数组
        }
      }
    };

    // 处理反馈
    const handleEdit = (row) => {
        // 处理反馈，跳转到处理页面
        try {
            if (!row || typeof row !== 'object' || !row.id) {
                console.error('无效的反馈数据:', row);
                if (window.R && typeof window.R.msgError === 'function') {
                    window.R.msgError('数据异常，无法处理');
                } else {
                    alert('数据异常，无法处理');
                }
                return;
            }
            console.log("处理反馈", row);
            window.location.href = new URL(`/science/feedback/create?id=${row.id}`, window.location.origin).href;
        } catch (error) {
            console.error('处理反馈失败:', error);
            if (window.R && typeof window.R.msgError === 'function') {
                window.R.msgError('操作失败');
            }
        }
    };

    // 查看详情
    const handleView = (row) => {
        // 查看详情功能，跳转到详情页面
        try {
            if (!row || typeof row !== 'object' || !row.id) {
                console.error('无效的反馈数据:', row);
                if (window.R && typeof window.R.msgError === 'function') {
                    window.R.msgError('数据异常，无法查看');
                } else {
                    alert('数据异常，无法查看');
                }
                return;
            }
            console.log("查看反馈详情", row);
            window.location.href = new URL(`/science/feedback/detail?id=${row.id}`, window.location.origin).href;
        } catch (error) {
            console.error('查看反馈详情失败:', error);
            if (window.R && typeof window.R.msgError === 'function') {
                window.R.msgError('操作失败');
            }
        }
    };

    const handleStatusChange = async (row) => {
        try {
            // 切换状态功能
            const newStatus = row.status === 0 ? 1 : row.status === 1 ? 2 : 0;
            const res = await K.feedback.update({
                id: row.id,
                status: newStatus
            });
            if (res.error) {
                R.msgError(res.msg || "状态更新失败");
                return;
            }
            R.msgSuccess("状态更新成功");
            fetchList(); // 重新获取列表数据
        } catch (err) {
            console.error("update status error", err);
            R.msgError("状态更新失败");
        }
    };

    const handleSearch = () => {
      pagination.page = 1;
      fetchList();
    };

    const resetFilters = () => {
      filters.id = "";
      filters.user = "";
      filters.scene = "";
      filters.status = "";
      pagination.page = 1;
      fetchList();
    };

    const handlePageChange = (page) => {
      pagination.page = page;
      fetchList();
    };

    const handleSizeChange = (size) => {
      pagination.pageSize = size;
      pagination.page = 1;
      fetchList();
    };

    // 初始加载数据
    fetchList();

    // 删除功能
    const handleDelete = async (row) => {
      try {
        // 使用 window.confirm 替代 Vue 的 $confirm
        const confirmResult = window.confirm('确定要删除这条反馈记录吗？删除后将无法恢复！');
        if (confirmResult) {
            // 调用删除API
            const res = await K.feedback.delete({id: row.id});
            if (res.error) {
                R.msgError(res.msg || '删除失败');
                return;
            }

            R.msgSuccess('删除成功');
            fetchList(); // 重新获取列表数据
        }
      } catch (err) {
        console.error('delete error', err);
        R.msgError('删除失败');
      }
    };

    return {
      filters,
      tableData,
      loading,
      pagination,
      handleSearch,
      resetFilters,
      handlePageChange,
      handleSizeChange,
      handleEdit,
      handleView,
      handleStatusChange,
      handleDelete,
      formatStatusText,
      formatSceneText,
      formatTimestamp
    };
  },
  render() {
    const d = this,
      a = u("el-card"),
      w = u("el-form"),
      p = u("el-form-item"),
      k = u("el-input"),
      b = u("el-select"),
      h = u("el-option"),
      q = u("el-button"),
      N = u("el-table"),
      m = u("el-table-column"),
      $ = u("el-tag"),
      P = u("el-image"),
      L = u("el-pagination"),
      T = ee("loading");
    return (
      i(),
      z("div", Ye, [
        e(
          a,
          { class: "border-none mt-2", shadow: "never" },
          {
            default: l(() => [
              f("div", Je, [
                f("div", { class: "filters d-flex align-items-center" }),
                e(
                  w,
                  { 
                    model: d.filters,
                    inline: "",
                    class: "d-inline-flex flex-wrap"
                  },
                  {
                    default: l(() => [
                      e(
                        p,
                        { label: "ID", prop: "id", class: "mr-3" },
                        {
                          default: l(() => [
                            e(
                              k,
                              { 
                                modelValue: d.filters.id,
                                "onUpdate:modelValue":
                                  d.$_id || (d.$_id = (t) => (d.filters.id = t)),
                                clearable: "",
                                placeholder: "请输入ID",
                                style: { width: '150px' },
                                onKeyup:
                                  d.$_enterId ||
                                  (d.$_enterId = (t) =>
                                    t.key === "Enter" && d.handleSearch()),
                              },
                              null,
                              8,
                              ["modelValue", "onKeyup"],
                            ),
                          ]),
                          _: 1,
                        },
                      ),
                      e(
                        p,
                        { label: "场景", prop: "scene", class: "mr-3" },
                        {
                          default: l(() => [
                            e(
                              b,
                              { 
                                modelValue: d.filters.scene,
                                "onUpdate:modelValue":
                                  d.$_scene ||
                                  (d.$_scene = (t) => (d.filters.scene = t)),
                                placeholder: "全部场景",
                                clearable: "",
                                style: { width: '150px' },
                              },
                              {
                                default: l(() => [
                                  (i(!0),
                                  z(
                                    J,
                                    null,
                                    X(
                                      SCENE_OPTIONS,
                                      (t) => (
                                        i(),
                                        y(
                                          h,
                                          {
                                            key: t.value,
                                            label: t.label,
                                            value: t.value,
                                          },
                                          null,
                                          8,
                                          ["label", "value"],
                                        )
                                      ),
                                    ),
                                    128,
                                  )),
                                ]),
                                _: 1,
                              },
                              8,
                              ["modelValue"],
                            ),
                          ]),
                          _: 1,
                        },
                      ),
                      // e(
                      //   p,
                      //   { label: "分类", prop: "category_id" },
                      //   {
                      //     default: l(() => [
                      //       e(
                      //         b,
                      //         {
                      //           modelValue: d.filters.category_id,
                      //           "onUpdate:modelValue":
                      //             d.$_category ||
                      //             (d.$_category = (t) =>
                      //               (d.filters.category_id = t)),
                      //           placeholder: "全部分类",
                      //           clearable: "",
                      //         },
                      //         {
                      //           default: l(() => [
                      //             (i(!0),
                      //             z(
                      //               J,
                      //               null,
                      //               X(
                      //                 d.categories,
                      //                 (t) => (
                      //                   i(),
                      //                   y(
                      //                     h,
                      //                     {
                      //                       key: t.id,
                      //                       label: t.name,
                      //                       value: t.id,
                      //                     },
                      //                     null,
                      //                     8,
                      //                     ["label", "value"],
                      //                   )
                      //                 ),
                      //               ),
                      //               128,
                      //             )),
                      //           ]),
                      //           _: 1,
                      //         },
                      //         8,
                      //         ["modelValue"],
                      //       ),
                      //     ]),
                      //     _: 1,
                      //   },
                      // ),
                      e(
                        p,
                        { label: "用户", prop: "user", class: "mr-3" },
                        {
                          default: l(() => [
                            e(
                              k,
                              { 
                                modelValue: d.filters.user,
                                "onUpdate:modelValue":
                                  d.$_user || (d.$_user = (t) => (d.filters.user = t)),
                                clearable: "",
                                placeholder: "请输入用户名",
                                style: { width: '150px' },
                                onKeyup:
                                      d.$_enterUser ||
                                      (d.$_enterUser = (t) =>
                                        t.key === "Enter" && d.handleSearch()),
                              },
                              null,
                              8,
                              ["modelValue", "onKeyup"],
                            ),
                          ]),
                          _: 1,
                        },
                      ),
                      e(
                        p,
                        { label: "状态", prop: "status", class: "mr-3" },
                        {
                          default: l(() => [
                            e(
                              b,
                              { 
                                modelValue: d.filters.status,
                                "onUpdate:modelValue":
                                  d.$_status ||
                                  (d.$_status = (t) => (d.filters.status = t)),
                                placeholder: "全部状态",
                                clearable: "",
                                style: { width: '150px' },
                              },
                              {
                                default: l(() => [
                                  (i(!0),
                                  z(
                                    J,
                                    null,
                                    X(
                                      STATUS_OPTIONS,
                                      (t) => (
                                        i(),
                                        y(
                                          h,
                                          {
                                            key: t.value,
                                            label: t.label,
                                            value: t.value,
                                          },
                                          null,
                                          8,
                                          ["label", "value"],
                                        )
                                      ),
                                    ),
                                    128,
                                  )),
                                ]),
                                _: 1,
                              },
                              8,
                              ["modelValue"],
                            ),
                          ]),
                          _: 1,
                        },
                      ),
                      e(
                        p,
                        { class: "mr-3", style: { "margin-right": "8px" } },
                        {
                          default: l(() => [
                            e(
                              q,
                              {
                                type: "primary",
                                icon: "Search",
                                onClick: d.handleSearch,
                                size: "small",
                              },
                              {
                                default: l(() => [s("查询")]),
                                _: 1,
                              },
                              8,
                              ["onClick"],
                            ),
                            e(
                        q,
                        { icon: "Refresh", onClick: d.resetFilters, size: "small" },
                        {
                          default: l(() => [s("重置")]),
                          _: 1,
                        },
                        8,
                        ["onClick"],
                      ),
                      // e(
                      //   q,
                      //   {
                      //     type: "primary",
                      //     style: { marginLeft: "10px" },
                      //      onClick: () => d.handleAdd()
                      //   },
                      //   {
                      //     default: l(() => [s("新增")]),
                      //     _: 1,
                      //   },
                      //   8,
                      //   ["onClick"],
                      // ),
                          ]),
                          _: 1,
                        },
                      ),
                    ]),
                    _: 1,
                  },
                  8,
                  ["model"],
                ),
              ]),
            ]),
            _: 1,
          },
        ),
        e(
          a,
          { class: "border-none mt-3", shadow: "never" },
          {
            default: l(() => [
              g(
                e(
                  N,
                  {
                    data: (function() {
                      try {
                        // 确保d存在且是对象
                        if (!d || typeof d !== 'object') {
                          console.warn('表格配置对象不存在或无效');
                          return [];
                        }
                        // 确保tableData存在且是数组
                        const tableData = d.tableData;
                        if (!tableData || !Array.isArray(tableData)) {
                          console.warn('表格数据不存在或不是数组');
                          return [];
                        }
                        // 过滤并验证每一行数据
                        return tableData.filter(row => {
                          if (!row || typeof row !== 'object') {
                            return false;
                          }
                          // 确保images属性是有效数组
                          if (row.images !== undefined && !Array.isArray(row.images)) {
                            row.images = [];
                          }
                          return true;
                        });
                      } catch (error) {
                        console.error('处理表格数据时发生错误:', error);
                        return [];
                      }
                    })(),
                    size: "large",
                    stripe: "",
                    "row-key": "id",
                    "header-cell-style": {
                      background: "var(--el-bg-color-page)",
                    },
                  },
                  {
                    default: l(() => [
                      e(m, { prop: "id", label: "ID", width: "85" }),
                      e(
                        m,
                        { label: "场景", width: "120" },
                        {
                          default: l(({ row: t }) => [
                            s(V(d.formatSceneText ? d.formatSceneText(t.scene) : (t.scene || "-"))),
                          ]),
                          _: 1,
                        },
                      ),
                       e(
                        m,
                        { label: "用户", width: "180" },
                        {
                          // 尝试使用原始结构，但增加错误处理
                          default: l(({ row }) => {
                            // 先确保row对象可用
                            if (!row) return [s(V('无数据'), 1)];
                            
                            // 尝试访问user对象的不同方式
                            let userName = '用户ID ' + (row.user_id || '未知');
                        
                            try {
                              // 最基本的访问方式
                              if (row.user && row.user.name) {
                                userName = row.user.name;
                                userName = userName + ('（ID:' + row.user_id + '）');
                              }
                            } catch (e) {
                              // 忽略错误，使用默认值
                            }
                            
                            return [s(V(userName), 1)];
                          }),
                          _: 1,
                        },
                      ),
                      e(
                        m,
                        { label: "反馈内容", width: "400", "show-overflow-tooltip": "" },
                        {
                          default: l(({ row: t }) => [
                            s(V(t.content || "-"), 1),
                          ]),
                          _: 1,
                        },
                      ),
                      e(
                        m,
                        { label: "联系方式", width: "150", "show-overflow-tooltip": "" },
                        {
                          default: l(({ row: t }) => [
                            s(V(t.contact || "-"), 1),
                          ]),
                          _: 1,
                        },
                      ),
                      e(
                        m,
                        { label: "IP地址", width: "150", "show-overflow-tooltip": "" },
                        {
                          default: l(({ row: t }) => [
                            s(V(t.ip || "-"), 1),
                          ]),
                          _: 1,
                        },
                      ),
                      e(
                        m,
                        { label: "提交时间", width: "180" },
                        {
                          default: l(({ row: t }) => [
                            s(V(d.formatTimestamp ? d.formatTimestamp(t.create_time) : (t.create_time || "-"))),
                          ]),
                          _: 1,
                        },
                      ),
                      e(
                        m,
                        { label: "更新时间", width: "180" },
                        {
                          default: l(({ row: t }) => [
                            s(V(d.formatTimestamp ? d.formatTimestamp(t.update_time) : (t.update_time || "-"))),
                          ]),
                          _: 1,
                        },
                      ),
                      e(
                        m,
                        { label: "状态", width: "100" },
                        {
                          default: l(({ row: t }) => [
                            e(
                              $,
                              { 
                                type: t.status === 1 ? "success" : 
                                       t.status === 2 ? "info" : 
                                       t.status === 0 ? "warning" : "default",
                                onClick: () => d.handleStatusChange(t)
                              },
                              {
                                default: l(() => [
                                  s(V(formatStatusText(t.status)), 1),
                                ]),
                                _: 2,
                              },
                              1032,
                              ["type", "onClick"],
                            ),
                          ]),
                          _: 1,
                        },
                      ),
                      e(
                        m,
                        { label: "操作", width: "200", fixed: "right" },
                        {
                          default: l(({ row: t }) => [
                            // e(
                            //   q,
                            //   {
                            //     type: "primary",
                            //     size: "small",
                            //     style: { marginRight: "10px" },
                            //     onClick: () => d.handleView(t)
                            //   },
                            //   {
                            //     default: l(() => [s("查看")]),
                            //     _: 1,
                            //   },
                            //   8,
                            //   ["onClick"],
                            // ),
                            // e(
                            //   q,
                            //   {
                            //     type: "primary",
                            //     size: "small",
                            //     style: { marginRight: "10px" },
                            //     onClick: () => d.handleView(t)
                            //   },
                            //   {
                            //     default: l(() => [s("查看")]),
                            //     _: 1,
                            //   },
                            //   8,
                            //   ["onClick"],
                            // ),
                            e(
                              q,
                              {
                                type: "success",
                                size: "small",
                                style: { marginRight: "10px" },
                                onClick: () => d.handleEdit(t)
                              },
                              {
                                default: l(() => [s("处理")]),
                                _: 1,
                              },
                              8,
                              ["onClick"],
                            ),
                            e(
                              q,
                              {
                                type: "danger",
                                size: "small",
                                onClick: () => d.handleDelete(t)
                              },
                              {
                                default: l(() => [s("删除")]),
                                _: 1,
                              },
                              8,
                              ["onClick"],
                            )
                          ]),
                          _: 1,
                        },
                      ),
                      

                    ]),
                    _: 1,
                  },
                  8,
                  ["data", "header-cell-style"],
                ),
                [[T, d.loading]],
              ),
              f("div", Qe, [
                e(
                  L,
                  {
                    background: "",
                    layout: "total, sizes, prev, pager, next, jumper",
                    total: d.pagination.total,
                    "page-sizes": [10, 20, 50, 100],
                    "current-page": d.pagination.page,
                    "page-size": d.pagination.pageSize,
                    onCurrentChange: d.handlePageChange,
                    onSizeChange: d.handleSizeChange,
                    "hide-on-single-page": false,
                  },
                  null,
                  8,
                  [
                    "total",
                    "current-page",
                    "page-size",
                    "onCurrentChange",
                    "onSizeChange",
                    "hide-on-single-page",
                  ],
                ),
              ]),
            ]),
            _: 1,
          },
        ),
      ])
    );
  },
};

export { et as default };
